﻿using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.Core;
using HslCommunication.Profinet.AllenBradley;
using HslCommunication.Reflection;

namespace HslCommunication.Profinet.Omron
{
	/// <summary>
	/// 欧姆龙PLC的CIP协议的类，支持NJ,NX,NY系列PLC，支持tag名的方式读写数据，假设你读取的是局部变量，那么使用 Program:MainProgram.变量名<br />
	/// Omron PLC's CIP protocol class, support NJ, NX, NY series PLC, support tag name read and write data, assuming you read local variables, then use Program: MainProgram. Variable name
	/// </summary>
	// Token: 0x02000057 RID: 87
	public class OmronCipNet : AllenBradleyNet
	{
		/// <summary>
		/// Instantiate a communication object for a OmronCipNet PLC protocol
		/// </summary>
		// Token: 0x060006FB RID: 1787 RVA: 0x00024C5C File Offset: 0x00022E5C
		public OmronCipNet()
		{
		}

		/// <summary>
		/// Specify the IP address and port to instantiate a communication object for a OmronCipNet PLC protocol
		/// </summary>
		/// <param name="ipAddress">PLC IpAddress</param>
		/// <param name="port">PLC Port</param>
		// Token: 0x060006FC RID: 1788 RVA: 0x00024C66 File Offset: 0x00022E66
		public OmronCipNet(string ipAddress, int port = 44818) : base(ipAddress, port)
		{
		}

		/// <inheritdoc />
		// Token: 0x060006FD RID: 1789 RVA: 0x00024C74 File Offset: 0x00022E74
		[HslMqttApi("ReadByteArray", "")]
		public override OperateResult<byte[]> Read(string address, ushort length)
		{
			bool flag = length > 1;
			OperateResult<byte[]> result;
			if (flag)
			{
				result = base.Read(new string[]
				{
					address
				}, new int[]
				{
					1
				});
			}
			else
			{
				result = base.Read(new string[]
				{
					address
				}, new int[]
				{
					(int)length
				});
			}
			return result;
		}

		/// <inheritdoc />
		// Token: 0x060006FE RID: 1790 RVA: 0x00024CC8 File Offset: 0x00022EC8
		[HslMqttApi("ReadInt16Array", "")]
		public override OperateResult<short[]> ReadInt16(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<short[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt16(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt16(m, (startIndex < 0) ? 0 : (startIndex * 2), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x060006FF RID: 1791 RVA: 0x00024D40 File Offset: 0x00022F40
		[HslMqttApi("ReadUInt16Array", "")]
		public override OperateResult<ushort[]> ReadUInt16(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<ushort[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt16(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt16(m, (startIndex < 0) ? 0 : (startIndex * 2), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000700 RID: 1792 RVA: 0x00024DB8 File Offset: 0x00022FB8
		[HslMqttApi("ReadInt32Array", "")]
		public override OperateResult<int[]> ReadInt32(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<int[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt32(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt32(m, (startIndex < 0) ? 0 : (startIndex * 4), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000701 RID: 1793 RVA: 0x00024E30 File Offset: 0x00023030
		[HslMqttApi("ReadUInt32Array", "")]
		public override OperateResult<uint[]> ReadUInt32(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<uint[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt32(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt32(m, (startIndex < 0) ? 0 : (startIndex * 4), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000702 RID: 1794 RVA: 0x00024EA8 File Offset: 0x000230A8
		[HslMqttApi("ReadFloatArray", "")]
		public override OperateResult<float[]> ReadFloat(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<float[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransSingle(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransSingle(m, (startIndex < 0) ? 0 : (startIndex * 4), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000703 RID: 1795 RVA: 0x00024F20 File Offset: 0x00023120
		[HslMqttApi("ReadInt64Array", "")]
		public override OperateResult<long[]> ReadInt64(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<long[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt64(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransInt64(m, (startIndex < 0) ? 0 : (startIndex * 8), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000704 RID: 1796 RVA: 0x00024F98 File Offset: 0x00023198
		[HslMqttApi("ReadUInt64Array", "")]
		public override OperateResult<ulong[]> ReadUInt64(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<ulong[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt64(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransUInt64(m, (startIndex < 0) ? 0 : (startIndex * 8), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000705 RID: 1797 RVA: 0x00025010 File Offset: 0x00023210
		[HslMqttApi("ReadDoubleArray", "")]
		public override OperateResult<double[]> ReadDouble(string address, ushort length)
		{
			bool flag = length == 1;
			OperateResult<double[]> resultFromBytes;
			if (flag)
			{
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransDouble(m, 0, (int)length));
			}
			else
			{
				int startIndex = HslHelper.ExtractStartIndex(ref address);
				resultFromBytes = ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, 1), (byte[] m) => this.ByteTransform.TransDouble(m, (startIndex < 0) ? 0 : (startIndex * 8), (int)length));
			}
			return resultFromBytes;
		}

		/// <inheritdoc />
		// Token: 0x06000706 RID: 1798 RVA: 0x00025088 File Offset: 0x00023288
		public override OperateResult<string> ReadString(string address, ushort length, Encoding encoding)
		{
			OperateResult<byte[]> operateResult = this.Read(address, length);
			bool flag = !operateResult.IsSuccess;
			OperateResult<string> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<string>(operateResult);
			}
			else
			{
				int count = (int)base.ByteTransform.TransUInt16(operateResult.Content, 0);
				result = OperateResult.CreateSuccessResult<string>(encoding.GetString(operateResult.Content, 2, count));
			}
			return result;
		}

		/// <inheritdoc />
		// Token: 0x06000707 RID: 1799 RVA: 0x000250E0 File Offset: 0x000232E0
		[HslMqttApi("WriteString", "")]
		public override OperateResult Write(string address, string value)
		{
			bool flag = string.IsNullOrEmpty(value);
			if (flag)
			{
				value = string.Empty;
			}
			byte[] array = SoftBasic.SpliceArray<byte>(new byte[][]
			{
				new byte[2],
				SoftBasic.ArrayExpandToLengthEven<byte>(Encoding.ASCII.GetBytes(value))
			});
			array[0] = BitConverter.GetBytes(array.Length - 2)[0];
			array[1] = BitConverter.GetBytes(array.Length - 2)[1];
			return base.WriteTag(address, 208, array, 1);
		}

		/// <inheritdoc />
		// Token: 0x06000708 RID: 1800 RVA: 0x00025158 File Offset: 0x00023358
		[HslMqttApi("WriteByte", "")]
		public override OperateResult Write(string address, byte value)
		{
			ushort typeCode = 209;
			byte[] array = new byte[2];
			array[0] = value;
			return this.WriteTag(address, typeCode, array, 1);
		}

		/// <inheritdoc />
		// Token: 0x06000709 RID: 1801 RVA: 0x00025184 File Offset: 0x00023384
		public override OperateResult WriteTag(string address, ushort typeCode, byte[] value, int length = 1)
		{
			return base.WriteTag(address, typeCode, value, 1);
		}

		/// <inheritdoc cref="M:HslCommunication.Profinet.Omron.OmronCipNet.Read(System.String,System.UInt16)" />
		// Token: 0x0600070A RID: 1802 RVA: 0x000251A0 File Offset: 0x000233A0
		[DebuggerStepThrough]
		public override Task<OperateResult<byte[]>> ReadAsync(string address, ushort length)
		{
			OmronCipNet.<ReadAsync>d__15 <ReadAsync>d__ = new OmronCipNet.<ReadAsync>d__15();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.address = address;
			<ReadAsync>d__.length = length;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<OmronCipNet.<ReadAsync>d__15>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600070B RID: 1803 RVA: 0x000251F4 File Offset: 0x000233F4
		[DebuggerStepThrough]
		public override Task<OperateResult<short[]>> ReadInt16Async(string address, ushort length)
		{
			OmronCipNet.<ReadInt16Async>d__16 <ReadInt16Async>d__ = new OmronCipNet.<ReadInt16Async>d__16();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short[]>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.length = length;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<OmronCipNet.<ReadInt16Async>d__16>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600070C RID: 1804 RVA: 0x00025248 File Offset: 0x00023448
		[DebuggerStepThrough]
		public override Task<OperateResult<ushort[]>> ReadUInt16Async(string address, ushort length)
		{
			OmronCipNet.<ReadUInt16Async>d__17 <ReadUInt16Async>d__ = new OmronCipNet.<ReadUInt16Async>d__17();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort[]>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.length = length;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<OmronCipNet.<ReadUInt16Async>d__17>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600070D RID: 1805 RVA: 0x0002529C File Offset: 0x0002349C
		[DebuggerStepThrough]
		public override Task<OperateResult<int[]>> ReadInt32Async(string address, ushort length)
		{
			OmronCipNet.<ReadInt32Async>d__18 <ReadInt32Async>d__ = new OmronCipNet.<ReadInt32Async>d__18();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int[]>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.length = length;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<OmronCipNet.<ReadInt32Async>d__18>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600070E RID: 1806 RVA: 0x000252F0 File Offset: 0x000234F0
		[DebuggerStepThrough]
		public override Task<OperateResult<uint[]>> ReadUInt32Async(string address, ushort length)
		{
			OmronCipNet.<ReadUInt32Async>d__19 <ReadUInt32Async>d__ = new OmronCipNet.<ReadUInt32Async>d__19();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint[]>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.length = length;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<OmronCipNet.<ReadUInt32Async>d__19>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600070F RID: 1807 RVA: 0x00025344 File Offset: 0x00023544
		[DebuggerStepThrough]
		public override Task<OperateResult<float[]>> ReadFloatAsync(string address, ushort length)
		{
			OmronCipNet.<ReadFloatAsync>d__20 <ReadFloatAsync>d__ = new OmronCipNet.<ReadFloatAsync>d__20();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float[]>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.length = length;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<OmronCipNet.<ReadFloatAsync>d__20>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000710 RID: 1808 RVA: 0x00025398 File Offset: 0x00023598
		[DebuggerStepThrough]
		public override Task<OperateResult<long[]>> ReadInt64Async(string address, ushort length)
		{
			OmronCipNet.<ReadInt64Async>d__21 <ReadInt64Async>d__ = new OmronCipNet.<ReadInt64Async>d__21();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long[]>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.length = length;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<OmronCipNet.<ReadInt64Async>d__21>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000711 RID: 1809 RVA: 0x000253EC File Offset: 0x000235EC
		[DebuggerStepThrough]
		public override Task<OperateResult<ulong[]>> ReadUInt64Async(string address, ushort length)
		{
			OmronCipNet.<ReadUInt64Async>d__22 <ReadUInt64Async>d__ = new OmronCipNet.<ReadUInt64Async>d__22();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong[]>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.length = length;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<OmronCipNet.<ReadUInt64Async>d__22>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000712 RID: 1810 RVA: 0x00025440 File Offset: 0x00023640
		[DebuggerStepThrough]
		public override Task<OperateResult<double[]>> ReadDoubleAsync(string address, ushort length)
		{
			OmronCipNet.<ReadDoubleAsync>d__23 <ReadDoubleAsync>d__ = new OmronCipNet.<ReadDoubleAsync>d__23();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double[]>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.length = length;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<OmronCipNet.<ReadDoubleAsync>d__23>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000713 RID: 1811 RVA: 0x00025494 File Offset: 0x00023694
		[DebuggerStepThrough]
		public override Task<OperateResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding)
		{
			OmronCipNet.<ReadStringAsync>d__24 <ReadStringAsync>d__ = new OmronCipNet.<ReadStringAsync>d__24();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.encoding = encoding;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<OmronCipNet.<ReadStringAsync>d__24>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000714 RID: 1812 RVA: 0x000254F0 File Offset: 0x000236F0
		[DebuggerStepThrough]
		public override Task<OperateResult> WriteAsync(string address, string value)
		{
			OmronCipNet.<WriteAsync>d__25 <WriteAsync>d__ = new OmronCipNet.<WriteAsync>d__25();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<OmronCipNet.<WriteAsync>d__25>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Profinet.Omron.OmronCipNet.Write(System.String,System.Byte)" />
		// Token: 0x06000715 RID: 1813 RVA: 0x00025544 File Offset: 0x00023744
		[DebuggerStepThrough]
		public override Task<OperateResult> WriteAsync(string address, byte value)
		{
			OmronCipNet.<WriteAsync>d__26 <WriteAsync>d__ = new OmronCipNet.<WriteAsync>d__26();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<OmronCipNet.<WriteAsync>d__26>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000716 RID: 1814 RVA: 0x00025598 File Offset: 0x00023798
		[DebuggerStepThrough]
		public override Task<OperateResult> WriteTagAsync(string address, ushort typeCode, byte[] value, int length = 1)
		{
			OmronCipNet.<WriteTagAsync>d__27 <WriteTagAsync>d__ = new OmronCipNet.<WriteTagAsync>d__27();
			<WriteTagAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteTagAsync>d__.<>4__this = this;
			<WriteTagAsync>d__.address = address;
			<WriteTagAsync>d__.typeCode = typeCode;
			<WriteTagAsync>d__.value = value;
			<WriteTagAsync>d__.length = length;
			<WriteTagAsync>d__.<>1__state = -1;
			<WriteTagAsync>d__.<>t__builder.Start<OmronCipNet.<WriteTagAsync>d__27>(ref <WriteTagAsync>d__);
			return <WriteTagAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x06000717 RID: 1815 RVA: 0x000255F9 File Offset: 0x000237F9
		public override string ToString()
		{
			return string.Format("OmronCipNet[{0}:{1}]", this.IpAddress, this.Port);
		}
	}
}
